[APPS-2961] Update: run local backend function calls in parallel, with per-call log prefixes - #603

// qa-parallel.mjs
// Usage: node qa-parallel.mjs <worktree> <app-dir>
// Starts a real Vite dev server with the built @datadog/vite-plugin, answers the Datadog runtime
// context query in-process (fake keys, no network), fires 3 sleepAndLog calls and 1 failing call
// at once to /__dd/executeAction, and prints timings, responses, query count and child pids.
import path from 'node:path';
import { pathToFileURL } from 'node:url';

const [worktree, appDir] = process.argv.slice(2);
const realFetch = globalThis.fetch;
let runtimeContextQueries = 0;
globalThis.fetch = async (input, init) => {
    const url = String(input instanceof Request ? input.url : input);
    if (url.endsWith('/api/v2/app-builder/queries/preview-async')) {
        runtimeContextQueries += 1;
        // Datadog's own latency, so calls that arrive together overlap their queries.
        await new Promise((resolve) => setTimeout(resolve, Number(process.env.QA_LATENCY_MS ?? 0)));
        return Response.json({ data: { id: 'qa-receipt' } });
    }
    if (url.includes('/api/v2/app-builder/queries/execution-long-polling/')) {
        const data = { Source: { initiator: { id: 'qa-user', orgId: 'qa-org' }, runAsUser: { id: 'qa-user', orgId: 'qa-org' } } };
        return Response.json({ data: { attributes: { done: true, outputs: { data } } } });
    }
    return realFetch(input, init);
};
process.env.BUILD_PLUGINS_ENV = 'test';
process.env.DD_API_KEY = 'qa-fake-api-key';
process.env.DD_APP_KEY = 'qa-fake-app-key';

const vite = await import(pathToFileURL(path.join(worktree, 'node_modules/vite/dist/node/index.js')).href);
const { datadogVitePlugin } = await import(
    pathToFileURL(path.join(worktree, 'packages/published/vite-plugin/dist/src/index.mjs')).href
);
const server = await vite.createServer({
    configFile: false,
    root: appDir,
    logLevel: 'error',
    server: { port: 0, strictPort: false, hmr: false },
    optimizeDeps: { noDiscovery: true },
    plugins: [datadogVitePlugin({ auth: { site: 'datadoghq.com' }, apps: { enable: true } })],
});
await server.listen();
const baseUrl = `http://localhost:${server.httpServer.address().port}`;
console.log(`QA dev server pid ${process.pid} at ${baseUrl}`);

const proxy = await (await realFetch(`${baseUrl}/src/parallel.backend.ts`)).text();
const names = Object.fromEntries(
    [...proxy.matchAll(/executeBackendFunction\("([^"]+)"/g)].map((m) => [m[1].split('.').pop(), m[1]]),
);
const call = async (fn, args) => {
    const startedAt = Date.now();
    const response = await realFetch(`${baseUrl}/__dd/executeAction`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ functionName: names[fn], args }),
    });
    return { fn, args, status: response.status, body: await response.text(), ms: Date.now() - startedAt };
};

const startedAt = Date.now();
const results = await Promise.all([
    call('sleepAndLog', [1500, 'a']),
    call('sleepAndLog', [1500, 'b']),
    call('failing', []),
    call('sleepAndLog', [1500, 'c']),
]);
const wallMs = Date.now() - startedAt;
for (const result of results) console.log('RESULT', JSON.stringify(result));
console.log(`WALL ${wallMs}ms for 3 x 1500ms calls plus 1 failing call`);
console.log(`RUNTIME_CONTEXT_QUERIES ${runtimeContextQueries}`);
const pids = results.filter((r) => r.status === 200).map((r) => JSON.parse(r.body).result.data.pid);
console.log(`CHILD_PIDS ${pids.join(' ')}`);
await server.close();

// log-requests.mjs, which run.sh preloads to log each Datadog request and long-poll body
// Preloaded with --import: logs method, URL and status of every fetch, plus the request body of
// preview-async POSTs and the response body of every long-poll, to $QA_NET_LOG.
import { appendFileSync } from 'node:fs';

const realFetch = globalThis.fetch;
const log = (line) => appendFileSync(process.env.QA_NET_LOG, line + '\n');
globalThis.fetch = async (input, init) => {
    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
    const method = init?.method ?? (typeof input === 'object' && 'method' in input ? input.method : 'GET');
    if (url.includes('preview-async') && typeof init?.body === 'string') {
        try {
            const spec = JSON.parse(init.body).data.attributes.query.properties.spec;
            const shown = spec.inputs?.script ? { ...spec, inputs: { ...spec.inputs, script: '<script>' } } : spec;
            log(`REQ ${method} ${url.split('?')[0]} spec=${JSON.stringify(shown)}`);
        } catch {
            log(`REQ ${method} ${url.split('?')[0]} <unparsed body>`);
        }
    }
    const res = await realFetch(input, init);
    if (url.includes('execution-long-polling')) {
        const text = await res.clone().text();
        log(`RES ${res.status} ${url.split('?')[0].replace(/execution-long-polling\/.*/, 'execution-long-polling/<receipt>')} body=${text.slice(0, 400)}`);
    } else {
        log(`RES ${res.status} ${method} ${url.split('?')[0]}`);
    }
    return res;
};

// transport-harness.mjs
// Calls backend functions through the plugin's own packed client runtime, the code app frontends use.
import { createHash } from 'node:crypto';
import { pathToFileURL } from 'node:url';

const [runtimePath, origin, ...specs] = process.argv.slice(2);
const realFetch = globalThis.fetch;
globalThis.fetch = async (url, init) => {
    try {
        return await realFetch(new URL(url, origin), init);
    } catch (error) {
        console.log(JSON.stringify({ fetchFailure: String(error.cause ?? error) }));
        throw error;
    }
};
await import(pathToFileURL(runtimePath).href);
for (const spec of specs) {
    const [fixture, fn] = spec.split(':');
    const name = `${createHash('sha256').update(`src/${fixture}`).digest('hex')}.${fn}`;
    try {
        const data = await globalThis.DD_APPS_RUNTIME.executeBackendFunction(name, []);
        console.log(JSON.stringify({ spec, resolved: data }));
    } catch (error) {
        console.log(JSON.stringify({ spec, name: error.name, message: error.message, statusCode: error.statusCode }));
    }
}